@milkdown/preset-commonmark 7.2.3 → 7.2.4

package/lib/index.es.js

@@ -1,12 +1,12 @@
-import { $markAttr as j, $markSchema as z, $command as g, $useKeymap as f, $node as Ye, $nodeAttr as N, $nodeSchema as I, $ctx as ee, $inputRule as L, pipe as wt, $prose as H, $remark as $ } from "@milkdown/utils";
-import { remarkStringifyOptionsCtx as U, commandsCtx as h, editorViewCtx as Z, serializerCtx as At, parserCtx as vt } from "@milkdown/core";
-import { toggleMark as Ht, setBlockType as _, wrapIn as te } from "@milkdown/prose/commands";
+import { $markAttr as V, $markSchema as j, $command as h, $useKeymap as N, $node as Ye, $nodeAttr as I, $nodeSchema as C, $ctx as Z, $inputRule as w, pipe as At, $prose as O, $remark as $ } from "@milkdown/utils";
+import { remarkStringifyOptionsCtx as Je, commandsCtx as y, editorViewCtx as X, serializerCtx as vt, parserCtx as Ht } from "@milkdown/core";
+import { toggleMark as ee, setBlockType as _, wrapIn as te } from "@milkdown/prose/commands";
 import { Fragment as Bt } from "@milkdown/prose/model";
-import { expectDomTypeError as S } from "@milkdown/exception";
-import { textblockTypeInputRule as Je, wrappingInputRule as re, InputRule as Qe } from "@milkdown/prose/inputrules";
-import Tt from "@sindresorhus/slugify";
-import { TextSelection as V, Selection as Xe, PluginKey as B, Plugin as T } from "@milkdown/prose/state";
-import { toggleMarkdownMark as Ze, findSelectedNodeOfType as Ot } from "@milkdown/prose";
+import { expectDomTypeError as A } from "@milkdown/exception";
+import { textblockTypeInputRule as Qe, wrappingInputRule as re, InputRule as Xe } from "@milkdown/prose/inputrules";
+import Ot from "@sindresorhus/slugify";
+import { TextSelection as G, Selection as Ze, PluginKey as T, Plugin as K } from "@milkdown/prose/state";
+import { findSelectedNodeOfType as Tt } from "@milkdown/prose";
 import { sinkListItem as Kt, liftListItem as et, splitListItem as Dt } from "@milkdown/prose/schema-list";
 import { ReplaceStep as Rt, AddMarkStep as Pt } from "@milkdown/prose/transform";
 import { Decoration as ze, DecorationSet as Ue } from "@milkdown/prose/view";
@@ -19,23 +19,23 @@ const tt = (t, e) => {
     return;
   }
   const a = [];
-  e.content.forEach((s, i, l) => {
-    l !== e.childCount - 1 && a.push(s);
+  e.content.forEach((s, l, i) => {
+    i !== e.childCount - 1 && a.push(s);
   }), t.next(Bt.fromArray(a));
 }, n = (t, e) => (Object.assign(t, {
   meta: {
     package: "@milkdown/preset-commonmark",
     ...e
   }
-}), t), ne = j("emphasis");
+}), t), ne = V("emphasis");
 n(ne, {
   displayName: "Attr<emphasis>",
   group: "Emphasis"
 });
-const Y = z("emphasis", (t) => ({
+const z = j("emphasis", (t) => ({
   attrs: {
     marker: {
-      default: t.get(U).emphasis || "*"
+      default: t.get(Je).emphasis || "*"
     }
   },
   parseDOM: [
@@ -59,27 +59,24 @@ const Y = z("emphasis", (t) => ({
     }
   }
 }));
-n(Y.mark, {
+n(z.mark, {
   displayName: "MarkSchema<emphasis>",
   group: "Emphasis"
 });
-n(Y.ctx, {
+n(z.ctx, {
   displayName: "MarkSchemaCtx<emphasis>",
   group: "Emphasis"
 });
-const oe = g("ToggleEmphasis", (t) => () => {
-  const e = Y.type(), r = t.get(U).emphasis || "*";
-  return Ze(e, r);
-});
+const oe = h("ToggleEmphasis", (t) => () => ee(z.type(t)));
 n(oe, {
   displayName: "Command<toggleEmphasisCommand>",
   group: "Emphasis"
 });
-const se = f("emphasisKeymap", {
+const se = N("emphasisKeymap", {
   ToggleEmphasis: {
     shortcuts: "Mod-i",
     command: (t) => {
-      const e = t.get(h);
+      const e = t.get(y);
       return () => e.call(oe.key);
     }
   }
@@ -92,15 +89,15 @@ n(se.shortcuts, {
   displayName: "Keymap<emphasis>",
   group: "Emphasis"
 });
-const le = j("strong");
+const le = V("strong");
 n(le, {
   displayName: "Attr<strong>",
   group: "Strong"
 });
-const J = z("strong", (t) => ({
+const U = j("strong", (t) => ({
   attrs: {
     marker: {
-      default: t.get(U).strong || "*"
+      default: t.get(Je).strong || "*"
     }
   },
   parseDOM: [
@@ -124,27 +121,24 @@ const J = z("strong", (t) => ({
     }
   }
 }));
-n(J.mark, {
+n(U.mark, {
   displayName: "MarkSchema<strong>",
   group: "Strong"
 });
-n(J.ctx, {
+n(U.ctx, {
   displayName: "MarkSchemaCtx<strong>",
   group: "Strong"
 });
-const ie = g("ToggleStrong", (t) => () => {
-  const e = J.type(), r = t.get(U).strong || "*", a = r + r;
-  return Ze(e, a);
-});
+const ie = h("ToggleStrong", (t) => () => ee(U.type(t)));
 n(ie, {
   displayName: "Command<toggleStrongCommand>",
   group: "Strong"
 });
-const ce = f("strongKeymap", {
+const ce = N("strongKeymap", {
   ToggleBold: {
     shortcuts: ["Mod-b"],
     command: (t) => {
-      const e = t.get(h);
+      const e = t.get(y);
       return () => e.call(ie.key);
     }
   }
@@ -157,12 +151,12 @@ n(ce.shortcuts, {
   displayName: "Keymap<strong>",
   group: "Strong"
 });
-const de = j("inlineCode");
+const de = V("inlineCode");
 n(de, {
   displayName: "Attr<inlineCode>",
   group: "InlineCode"
 });
-const b = z("inlineCode", (t) => ({
+const x = j("inlineCode", (t) => ({
   priority: 100,
   code: !0,
   inclusive: !1,
@@ -181,32 +175,32 @@ const b = z("inlineCode", (t) => ({
     }
   }
 }));
-n(b.mark, {
+n(x.mark, {
   displayName: "MarkSchema<inlineCode>",
   group: "InlineCode"
 });
-n(b.ctx, {
+n(x.ctx, {
   displayName: "MarkSchemaCtx<inlineCode>",
   group: "InlineCode"
 });
-const me = g("ToggleInlineCode", () => () => (t, e) => {
-  const { selection: r, tr: a } = t;
-  if (r.empty)
+const me = h("ToggleInlineCode", (t) => () => (e, r) => {
+  const { selection: a, tr: o } = e;
+  if (a.empty)
     return !1;
-  const { from: o, to: s } = r;
-  return t.doc.rangeHasMark(o, s, b.type()) ? (e == null || e(a.removeMark(o, s, b.type())), !0) : (Object.keys(t.schema.marks).filter((c) => c !== b.type.name).map((c) => t.schema.marks[c]).forEach((c) => {
-    a.removeMark(o, s, c);
-  }), e == null || e(a.addMark(o, s, b.type().create())), !0);
+  const { from: s, to: l } = a;
+  return e.doc.rangeHasMark(s, l, x.type(t)) ? (r == null || r(o.removeMark(s, l, x.type(t))), !0) : (Object.keys(e.schema.marks).filter((d) => d !== x.type.name).map((d) => e.schema.marks[d]).forEach((d) => {
+    o.removeMark(s, l, d);
+  }), r == null || r(o.addMark(s, l, x.type(t).create())), !0);
 });
 n(me, {
   displayName: "Command<toggleInlineCodeCommand>",
   group: "InlineCode"
 });
-const ue = f("inlineCodeKeymap", {
+const ue = N("inlineCodeKeymap", {
   ToggleInlineCode: {
     shortcuts: "Mod-e",
     command: (t) => {
-      const e = t.get(h);
+      const e = t.get(y);
       return () => e.call(me.key);
     }
   }
@@ -219,12 +213,12 @@ n(ue.shortcuts, {
   displayName: "Keymap<inlineCode>",
   group: "InlineCode"
 });
-const pe = j("link");
+const pe = V("link");
 n(pe, {
   displayName: "Attr<link>",
   group: "Link"
 });
-const v = z("link", (t) => ({
+const B = j("link", (t) => ({
   attrs: {
     href: {},
     title: { default: null }
@@ -234,7 +228,7 @@ const v = z("link", (t) => ({
       tag: "a[href]",
       getAttrs: (e) => {
         if (!(e instanceof HTMLElement))
-          throw S(e);
+          throw A(e);
         return { href: e.getAttribute("href"), title: e.getAttribute("title") };
       }
     }
@@ -257,31 +251,31 @@ const v = z("link", (t) => ({
     }
   }
 }));
-n(v.mark, {
+n(B.mark, {
   displayName: "MarkSchema<link>",
   group: "Link"
 });
-const rt = g("ToggleLink", () => (t = {}) => Ht(v.type(), t));
+const rt = h("ToggleLink", (t) => (e = {}) => ee(B.type(t), e));
 n(rt, {
   displayName: "Command<toggleLinkCommand>",
   group: "Link"
 });
-const at = g("UpdateLink", () => (t = {}) => (e, r) => {
-  if (!r)
+const at = h("UpdateLink", (t) => (e = {}) => (r, a) => {
+  if (!a)
     return !1;
-  let a, o = -1;
-  const { selection: s } = e, { from: i, to: l } = s;
-  if (e.doc.nodesBetween(i, i === l ? l + 1 : l, (p, k) => {
-    if (v.type().isInSet(p.marks))
-      return a = p, o = k, !1;
-  }), !a)
+  let o, s = -1;
+  const { selection: l } = r, { from: i, to: c } = l;
+  if (r.doc.nodesBetween(i, i === c ? c + 1 : c, (g, f) => {
+    if (B.type(t).isInSet(g.marks))
+      return o = g, s = f, !1;
+  }), !o)
     return !1;
-  const c = a.marks.find(({ type: p }) => p === v.type());
-  if (!c)
+  const d = o.marks.find(({ type: g }) => g === B.type(t));
+  if (!d)
     return !1;
-  const d = o, m = o + a.nodeSize, { tr: u } = e, y = v.type().create({ ...c.attrs, ...t });
-  return y ? (r(
-    u.removeMark(d, m, c).addMark(d, m, y).setSelection(new V(u.selection.$anchor)).scrollIntoView()
+  const m = s, p = s + o.nodeSize, { tr: u } = r, k = B.type(t).create({ ...d.attrs, ...e });
+  return k ? (a(
+    u.removeMark(m, p, d).addMark(m, p, k).setSelection(new G(u.selection.$anchor)).scrollIntoView()
   ), !0) : !1;
 });
 n(at, {
@@ -307,12 +301,12 @@ n(nt, {
   displayName: "NodeSchema<doc>",
   group: "Doc"
 });
-const ge = N("paragraph");
+const ge = I("paragraph");
 n(ge, {
   displayName: "Attr<paragraph>",
   group: "Paragraph"
 });
-const w = I("paragraph", (t) => ({
+const v = C("paragraph", (t) => ({
   content: "inline*",
   group: "block",
   parseDOM: [{ tag: "p" }],
@@ -330,24 +324,24 @@ const w = I("paragraph", (t) => ({
     }
   }
 }));
-n(w.node, {
+n(v.node, {
   displayName: "NodeSchema<paragraph>",
   group: "Paragraph"
 });
-n(w.ctx, {
+n(v.ctx, {
   displayName: "NodeSchemaCtx<paragraph>",
   group: "Paragraph"
 });
-const he = g("TurnIntoText", () => () => _(w.type()));
+const he = h("TurnIntoText", (t) => () => _(v.type(t)));
 n(he, {
   displayName: "Command<turnIntoTextCommand>",
   group: "Paragraph"
 });
-const ye = f("paragraphKeymap", {
+const ye = N("paragraphKeymap", {
   TurnIntoText: {
     shortcuts: "Mod-Alt-0",
     command: (t) => {
-      const e = t.get(h);
+      const e = t.get(y);
       return () => e.call(he.key);
     }
   }
@@ -360,18 +354,18 @@ n(ye.shortcuts, {
   displayName: "Keymap<paragraph>",
   group: "Paragraph"
 });
-const _t = Array(6).fill(0).map((t, e) => e + 1), $t = (t) => Tt(t.textContent), Q = ee($t, "headingIdGenerator");
-n(Q, {
+const _t = Array(6).fill(0).map((t, e) => e + 1), $t = (t) => Ot(t.textContent), Y = Z($t, "headingIdGenerator");
+n(Y, {
   displayName: "Ctx<HeadingIdGenerator>",
   group: "Heading"
 });
-const ke = N("heading");
+const ke = I("heading");
 n(ke, {
   displayName: "Attr<heading>",
   group: "Heading"
 });
-const A = I("heading", (t) => {
-  const e = t.get(Q.key);
+const H = C("heading", (t) => {
+  const e = t.get(Y.key);
   return {
     content: "inline*",
     group: "block",
@@ -388,7 +382,7 @@ const A = I("heading", (t) => {
       tag: `h${r}`,
       getAttrs: (a) => {
         if (!(a instanceof HTMLElement))
-          throw S(a);
+          throw A(a);
         return { level: r, id: a.id };
       }
     })),
@@ -415,17 +409,17 @@ const A = I("heading", (t) => {
     }
   };
 });
-n(A.node, {
+n(H.node, {
   displayName: "NodeSchema<heading>",
   group: "Heading"
 });
-n(A.ctx, {
+n(H.ctx, {
   displayName: "NodeSchemaCtx<heading>",
   group: "Heading"
 });
-const ot = L((t) => Je(/^(?<hashes>#+)\s$/, A.type(), (e) => {
-  var i, l;
-  const r = ((l = (i = e.groups) == null ? void 0 : i.hashes) == null ? void 0 : l.length) || 0, a = t.get(Z), { $from: o } = a.state.selection, s = o.node();
+const ot = w((t) => Qe(/^(?<hashes>#+)\s$/, H.type(t), (e) => {
+  var l, i;
+  const r = ((i = (l = e.groups) == null ? void 0 : l.hashes) == null ? void 0 : i.length) || 0, a = t.get(X), { $from: o } = a.state.selection, s = o.node();
   if (s.type.name === "heading") {
     let c = Number(s.attrs.level) + Number(r);
     return c > 6 && (c = 6), { level: c };
@@ -436,74 +430,74 @@ n(ot, {
   displayName: "InputRule<wrapInHeadingInputRule>",
   group: "Heading"
 });
-const M = g("WrapInHeading", () => (t) => (t ?? (t = 1), t < 1 ? _(w.type()) : _(A.type(), { level: t })));
-n(M, {
+const b = h("WrapInHeading", (t) => (e) => (e ?? (e = 1), e < 1 ? _(v.type(t)) : _(H.type(t), { level: e })));
+n(b, {
   displayName: "Command<wrapInHeadingCommand>",
   group: "Heading"
 });
-const fe = g("DowngradeHeading", () => () => (t, e, r) => {
-  const { $from: a } = t.selection, o = a.node();
-  if (o.type !== A.type() || !t.selection.empty || a.parentOffset !== 0)
+const fe = h("DowngradeHeading", (t) => () => (e, r, a) => {
+  const { $from: o } = e.selection, s = o.node();
+  if (s.type !== H.type(t) || !e.selection.empty || o.parentOffset !== 0)
     return !1;
-  const s = o.attrs.level - 1;
-  return s ? (e == null || e(
-    t.tr.setNodeMarkup(t.selection.$from.before(), void 0, {
-      ...o.attrs,
-      level: s
+  const l = s.attrs.level - 1;
+  return l ? (r == null || r(
+    e.tr.setNodeMarkup(e.selection.$from.before(), void 0, {
+      ...s.attrs,
+      level: l
     })
-  ), !0) : _(w.type())(t, e, r);
+  ), !0) : _(v.type(t))(e, r, a);
 });
 n(fe, {
   displayName: "Command<downgradeHeadingCommand>",
   group: "Heading"
 });
-const Ne = f("headingKeymap", {
+const Ne = N("headingKeymap", {
   TurnIntoH1: {
     shortcuts: "Mod-Alt-1",
     command: (t) => {
-      const e = t.get(h);
-      return () => e.call(M.key, 1);
+      const e = t.get(y);
+      return () => e.call(b.key, 1);
     }
   },
   TurnIntoH2: {
     shortcuts: "Mod-Alt-2",
     command: (t) => {
-      const e = t.get(h);
-      return () => e.call(M.key, 2);
+      const e = t.get(y);
+      return () => e.call(b.key, 2);
     }
   },
   TurnIntoH3: {
     shortcuts: "Mod-Alt-3",
     command: (t) => {
-      const e = t.get(h);
-      return () => e.call(M.key, 3);
+      const e = t.get(y);
+      return () => e.call(b.key, 3);
     }
   },
   TurnIntoH4: {
     shortcuts: "Mod-Alt-4",
     command: (t) => {
-      const e = t.get(h);
-      return () => e.call(M.key, 3);
+      const e = t.get(y);
+      return () => e.call(b.key, 4);
     }
   },
   TurnIntoH5: {
     shortcuts: "Mod-Alt-5",
     command: (t) => {
-      const e = t.get(h);
-      return () => e.call(M.key, 3);
+      const e = t.get(y);
+      return () => e.call(b.key, 5);
     }
   },
   TurnIntoH6: {
     shortcuts: "Mod-Alt-6",
     command: (t) => {
-      const e = t.get(h);
-      return () => e.call(M.key, 3);
+      const e = t.get(y);
+      return () => e.call(b.key, 6);
     }
   },
   DowngradeHeading: {
     shortcuts: ["Delete", "Backspace"],
     command: (t) => {
-      const e = t.get(h);
+      const e = t.get(y);
       return () => e.call(fe.key);
     }
   }
@@ -516,12 +510,12 @@ n(Ne.shortcuts, {
   displayName: "Keymap<heading>",
   group: "Heading"
 });
-const Ie = N("blockquote");
+const Ie = I("blockquote");
 n(Ie, {
   displayName: "Attr<blockquote>",
   group: "Blockquote"
 });
-const q = I("blockquote", (t) => ({
+const q = C("blockquote", (t) => ({
   content: "block+",
   group: "block",
   defining: !0,
@@ -548,21 +542,21 @@ n(q.ctx, {
   displayName: "NodeSchemaCtx<blockquote>",
   group: "Blockquote"
 });
-const st = L(() => re(/^\s*>\s$/, q.type()));
+const st = w((t) => re(/^\s*>\s$/, q.type(t)));
 n(st, {
   displayName: "InputRule<wrapInBlockquoteInputRule>",
   group: "Blockquote"
 });
-const Ce = g("WrapInBlockquote", () => () => te(q.type()));
+const Ce = h("WrapInBlockquote", (t) => () => te(q.type(t)));
 n(Ce, {
   displayName: "Command<wrapInBlockquoteCommand>",
   group: "Blockquote"
 });
-const Me = f("blockquoteKeymap", {
+const Me = N("blockquoteKeymap", {
   WrapInBlockquote: {
     shortcuts: "Mod-Shift-b",
     command: (t) => {
-      const e = t.get(h);
+      const e = t.get(y);
       return () => e.call(Ce.key);
     }
   }
@@ -575,7 +569,7 @@ n(Me.shortcuts, {
   displayName: "Keymap<blockquote>",
   group: "Blockquote"
 });
-const be = N("codeBlock", () => ({
+const be = I("codeBlock", () => ({
   pre: {},
   code: {}
 }));
@@ -583,7 +577,7 @@ n(be, {
   displayName: "Attr<codeBlock>",
   group: "CodeBlock"
 });
-const W = I("code_block", (t) => ({
+const W = C("code_block", (t) => ({
   content: "text*",
   group: "block",
   marks: "",
@@ -600,7 +594,7 @@ const W = I("code_block", (t) => ({
       preserveWhitespace: "full",
       getAttrs: (e) => {
         if (!(e instanceof HTMLElement))
-          throw S(e);
+          throw A(e);
         return { language: e.dataset.language };
       }
     }
@@ -641,49 +635,49 @@ n(W.ctx, {
   displayName: "NodeSchemaCtx<codeBlock>",
   group: "CodeBlock"
 });
-const lt = L(() => Je(/^```(?<language>[a-z]*)?[\s\n]$/, W.type(), (t) => {
-  var e;
+const lt = w((t) => Qe(/^```(?<language>[a-z]*)?[\s\n]$/, W.type(t), (e) => {
+  var r;
   return {
-    language: ((e = t.groups) == null ? void 0 : e.language) ?? ""
+    language: ((r = e.groups) == null ? void 0 : r.language) ?? ""
   };
 }));
 n(lt, {
   displayName: "InputRule<createCodeBlockInputRule>",
   group: "CodeBlock"
 });
-const xe = g("CreateCodeBlock", () => (t = "") => _(W.type(), { language: t }));
-n(xe, {
+const Le = h("CreateCodeBlock", (t) => (e = "") => _(W.type(t), { language: e }));
+n(Le, {
   displayName: "Command<createCodeBlockCommand>",
   group: "CodeBlock"
 });
-const qt = g("UpdateCodeBlockLanguage", () => ({ pos: t, language: e } = { pos: -1, language: "" }) => (r, a) => t >= 0 ? (a == null || a(r.tr.setNodeAttribute(t, "language", e)), !0) : !1);
+const qt = h("UpdateCodeBlockLanguage", () => ({ pos: t, language: e } = { pos: -1, language: "" }) => (r, a) => t >= 0 ? (a == null || a(r.tr.setNodeAttribute(t, "language", e)), !0) : !1);
 n(qt, {
   displayName: "Command<updateCodeBlockLanguageCommand>",
   group: "CodeBlock"
 });
-const Le = f("codeBlockKeymap", {
+const xe = N("codeBlockKeymap", {
   CreateCodeBlock: {
     shortcuts: "Mod-Alt-c",
     command: (t) => {
-      const e = t.get(h);
-      return () => e.call(xe.key);
+      const e = t.get(y);
+      return () => e.call(Le.key);
     }
   }
 });
-n(Le.ctx, {
+n(xe.ctx, {
   displayName: "KeymapCtx<codeBlock>",
   group: "CodeBlock"
 });
-n(Le.shortcuts, {
+n(xe.shortcuts, {
   displayName: "Keymap<codeBlock>",
   group: "CodeBlock"
 });
-const Se = N("image");
+const Se = I("image");
 n(Se, {
   displayName: "Attr<image>",
   group: "Image"
 });
-const O = I("image", (t) => ({
+const D = C("image", (t) => ({
   inline: !0,
   group: "inline",
   selectable: !0,
@@ -702,7 +696,7 @@ const O = I("image", (t) => ({
       tag: "img[src]",
       getAttrs: (e) => {
         if (!(e instanceof HTMLElement))
-          throw S(e);
+          throw A(e);
         return {
           src: e.getAttribute("src") || "",
           alt: e.getAttribute("alt") || "",
@@ -715,11 +709,11 @@ const O = I("image", (t) => ({
   parseMarkdown: {
     match: ({ type: e }) => e === "image",
     runner: (e, r, a) => {
-      const o = r.url, s = r.alt, i = r.title;
+      const o = r.url, s = r.alt, l = r.title;
       e.addNode(a, {
         src: o,
         alt: s,
-        title: i
+        title: l
       });
     }
   },
@@ -734,54 +728,54 @@ const O = I("image", (t) => ({
     }
   }
 }));
-n(O.node, {
+n(D.node, {
   displayName: "NodeSchema<image>",
   group: "Image"
 });
-n(O.ctx, {
+n(D.ctx, {
   displayName: "NodeSchemaCtx<image>",
   group: "Image"
 });
-const it = g("InsertImage", () => (t = {}) => (e, r) => {
-  if (!r)
+const it = h("InsertImage", (t) => (e = {}) => (r, a) => {
+  if (!a)
     return !0;
-  const { src: a = "", alt: o = "", title: s = "" } = t, i = O.type().create({ src: a, alt: o, title: s });
-  return i && r(e.tr.replaceSelectionWith(i).scrollIntoView()), !0;
+  const { src: o = "", alt: s = "", title: l = "" } = e, i = D.type(t).create({ src: o, alt: s, title: l });
+  return i && a(r.tr.replaceSelectionWith(i).scrollIntoView()), !0;
 });
 n(it, {
   displayName: "Command<insertImageCommand>",
   group: "Image"
 });
-const ct = g("UpdateImage", () => (t = {}) => (e, r) => {
-  const a = Ot(e.selection, O.type());
-  if (!a)
+const ct = h("UpdateImage", (t) => (e = {}) => (r, a) => {
+  const o = Tt(r.selection, D.type(t));
+  if (!o)
     return !1;
-  const { node: o, pos: s } = a, i = { ...o.attrs }, { src: l, alt: c, title: d } = t;
-  return l !== void 0 && (i.src = l), c !== void 0 && (i.alt = c), d !== void 0 && (i.title = d), r == null || r(e.tr.setNodeMarkup(s, void 0, i).scrollIntoView()), !0;
+  const { node: s, pos: l } = o, i = { ...s.attrs }, { src: c, alt: d, title: m } = e;
+  return c !== void 0 && (i.src = c), d !== void 0 && (i.alt = d), m !== void 0 && (i.title = m), a == null || a(r.tr.setNodeMarkup(l, void 0, i).scrollIntoView()), !0;
 });
 n(ct, {
   displayName: "Command<updateImageCommand>",
   group: "Image"
 });
-const Wt = L(() => new Qe(
+const Wt = w((t) => new Xe(
   /!\[(?<alt>.*?)]\((?<filename>.*?)\s*(?="|\))"?(?<title>[^"]+)?"?\)/,
-  (t, e, r, a) => {
-    const [o, s, i = "", l] = e;
-    return o ? t.tr.replaceWith(r, a, O.type().create({ src: i, alt: s, title: l })) : null;
+  (e, r, a, o) => {
+    const [s, l, i = "", c] = r;
+    return s ? e.tr.replaceWith(a, o, D.type(t).create({ src: i, alt: l, title: c })) : null;
   }
 ));
 n(Wt, {
   displayName: "InputRule<insertImageInputRule>",
   group: "Image"
 });
-const we = N("hardbreak", (t) => ({
+const we = I("hardbreak", (t) => ({
   "data-is-inline": t.attrs.isInline
 }));
 n(we, {
   displayName: "Attr<hardbreak>",
   group: "Hardbreak"
 });
-const x = I("hardbreak", (t) => ({
+const S = C("hardbreak", (t) => ({
   inline: !0,
   group: "inline",
   attrs: {
@@ -809,35 +803,35 @@ const x = I("hardbreak", (t) => ({
     }
   }
 }));
-n(x.node, {
+n(S.node, {
   displayName: "NodeSchema<hardbreak>",
   group: "Hardbreak"
 });
-n(x.ctx, {
+n(S.ctx, {
   displayName: "NodeSchemaCtx<hardbreak>",
   group: "Hardbreak"
 });
-const Ae = g("InsertHardbreak", () => () => (t, e) => {
-  var o;
-  const { selection: r, tr: a } = t;
-  if (r.empty) {
-    const s = r.$from.node();
-    if (s.childCount > 0 && ((o = s.lastChild) == null ? void 0 : o.type.name) === "hardbreak")
-      return e == null || e(
-        a.replaceRangeWith(r.to - 1, r.to, t.schema.node("paragraph")).setSelection(Xe.near(a.doc.resolve(r.to))).scrollIntoView()
+const Ae = h("InsertHardbreak", (t) => () => (e, r) => {
+  var s;
+  const { selection: a, tr: o } = e;
+  if (a.empty) {
+    const l = a.$from.node();
+    if (l.childCount > 0 && ((s = l.lastChild) == null ? void 0 : s.type.name) === "hardbreak")
+      return r == null || r(
+        o.replaceRangeWith(a.to - 1, a.to, e.schema.node("paragraph")).setSelection(Ze.near(o.doc.resolve(a.to))).scrollIntoView()
       ), !0;
   }
-  return e == null || e(a.setMeta("hardbreak", !0).replaceSelectionWith(x.type().create()).scrollIntoView()), !0;
+  return r == null || r(o.setMeta("hardbreak", !0).replaceSelectionWith(S.type(t).create()).scrollIntoView()), !0;
 });
 n(Ae, {
   displayName: "Command<insertHardbreakCommand>",
   group: "Hardbreak"
 });
-const ve = f("hardbreakKeymap", {
+const ve = N("hardbreakKeymap", {
   InsertHardbreak: {
     shortcuts: "Shift-Enter",
     command: (t) => {
-      const e = t.get(h);
+      const e = t.get(y);
       return () => e.call(Ae.key);
     }
   }
@@ -850,12 +844,12 @@ n(ve.shortcuts, {
   displayName: "Keymap<hardbreak>",
   group: "Hardbreak"
 });
-const He = N("hr");
+const He = I("hr");
 n(He, {
   displayName: "Attr<hr>",
   group: "Hr"
 });
-const F = I("hr", (t) => ({
+const F = C("hr", (t) => ({
   group: "block",
   parseDOM: [{ tag: "hr" }],
   toDOM: (e) => ["hr", t.get(He.key)(e)],
@@ -880,36 +874,36 @@ n(F.ctx, {
   displayName: "NodeSchemaCtx<hr>",
   group: "Hr"
 });
-const dt = L(() => new Qe(
+const dt = w((t) => new Xe(
   /^(?:---|___\s|\*\*\*\s)$/,
-  (t, e, r, a) => {
-    const { tr: o } = t;
-    return e[0] && o.replaceWith(r - 1, a, F.type().create()), o;
+  (e, r, a, o) => {
+    const { tr: s } = e;
+    return r[0] && s.replaceWith(a - 1, o, F.type(t).create()), s;
   }
 ));
 n(dt, {
   displayName: "InputRule<insertHrInputRule>",
   group: "Hr"
 });
-const mt = g("InsertHr", () => () => (t, e) => {
-  if (!e)
+const mt = h("InsertHr", (t) => () => (e, r) => {
+  if (!r)
     return !0;
-  const r = w.node.type().create(), { tr: a, selection: o } = t, { from: s } = o, i = F.type().create();
+  const a = v.node.type(t).create(), { tr: o, selection: s } = e, { from: l } = s, i = F.type(t).create();
   if (!i)
     return !0;
-  const l = a.replaceSelectionWith(i).insert(s, r), c = Xe.findFrom(l.doc.resolve(s), 1, !0);
-  return c && e(l.setSelection(c).scrollIntoView()), !0;
+  const c = o.replaceSelectionWith(i).insert(l, a), d = Ze.findFrom(c.doc.resolve(l), 1, !0);
+  return d && r(c.setSelection(d).scrollIntoView()), !0;
 });
 n(mt, {
   displayName: "Command<insertHrCommand>",
   group: "Hr"
 });
-const Be = N("bulletList");
+const Be = I("bulletList");
 n(Be, {
   displayName: "Attr<bulletList>",
   group: "BulletList"
 });
-const K = I("bullet_list", (t) => ({
+const R = C("bullet_list", (t) => ({
   content: "listItem+",
   group: "block",
   attrs: {
@@ -922,7 +916,7 @@ const K = I("bullet_list", (t) => ({
       tag: "ul",
       getAttrs: (e) => {
         if (!(e instanceof HTMLElement))
-          throw S(e);
+          throw A(e);
         return {
           spread: e.dataset.spread
         };
@@ -951,47 +945,47 @@ const K = I("bullet_list", (t) => ({
     }
   }
 }));
-n(K.node, {
+n(R.node, {
   displayName: "NodeSchema<bulletList>",
   group: "BulletList"
 });
-n(K.ctx, {
+n(R.ctx, {
   displayName: "NodeSchemaCtx<bulletList>",
   group: "BulletList"
 });
-const ut = L(() => re(/^\s*([-+*])\s$/, K.type()));
+const ut = w((t) => re(/^\s*([-+*])\s$/, R.type(t)));
 n(ut, {
   displayName: "InputRule<wrapInBulletListInputRule>",
   group: "BulletList"
 });
-const Te = g("WrapInBulletList", () => () => te(K.type()));
-n(Te, {
+const Oe = h("WrapInBulletList", (t) => () => te(R.type(t)));
+n(Oe, {
   displayName: "Command<wrapInBulletListCommand>",
   group: "BulletList"
 });
-const Oe = f("bulletListKeymap", {
+const Te = N("bulletListKeymap", {
   WrapInBulletList: {
     shortcuts: "Mod-Alt-8",
     command: (t) => {
-      const e = t.get(h);
-      return () => e.call(Te.key);
+      const e = t.get(y);
+      return () => e.call(Oe.key);
     }
   }
 });
-n(Oe.ctx, {
+n(Te.ctx, {
   displayName: "KeymapCtx<bulletListKeymap>",
   group: "BulletList"
 });
-n(Oe.shortcuts, {
+n(Te.shortcuts, {
   displayName: "Keymap<bulletListKeymap>",
   group: "BulletList"
 });
-const Ke = N("orderedList");
+const Ke = I("orderedList");
 n(Ke, {
   displayName: "Attr<orderedList>",
   group: "OrderedList"
 });
-const D = I("ordered_list", (t) => ({
+const P = C("ordered_list", (t) => ({
   content: "listItem+",
   group: "block",
   attrs: {
@@ -1007,7 +1001,7 @@ const D = I("ordered_list", (t) => ({
       tag: "ol",
       getAttrs: (e) => {
         if (!(e instanceof HTMLElement))
-          throw S(e);
+          throw A(e);
         return {
           spread: e.dataset.spread,
           order: e.hasAttribute("start") ? Number(e.getAttribute("start")) : 1
@@ -1038,34 +1032,34 @@ const D = I("ordered_list", (t) => ({
     }
   }
 }));
-n(D.node, {
+n(P.node, {
   displayName: "NodeSchema<orderedList>",
   group: "OrderedList"
 });
-n(D.ctx, {
+n(P.ctx, {
   displayName: "NodeSchemaCtx<orderedList>",
   group: "OrderedList"
 });
-const pt = L(() => re(
+const pt = w((t) => re(
   /^\s*(\d+)\.\s$/,
-  D.type(),
-  (t) => ({ order: Number(t[1]) }),
-  (t, e) => e.childCount + e.attrs.order === Number(t[1])
+  P.type(t),
+  (e) => ({ order: Number(e[1]) }),
+  (e, r) => r.childCount + r.attrs.order === Number(e[1])
 ));
 n(pt, {
   displayName: "InputRule<wrapInOrderedListInputRule>",
   group: "OrderedList"
 });
-const De = g("WrapInOrderedList", () => () => te(D.type()));
+const De = h("WrapInOrderedList", (t) => () => te(P.type(t)));
 n(De, {
   displayName: "Command<wrapInOrderedListCommand>",
   group: "OrderedList"
 });
-const Re = f("orderedListKeymap", {
+const Re = N("orderedListKeymap", {
   WrapInOrderedList: {
     shortcuts: "Mod-Alt-7",
     command: (t) => {
-      const e = t.get(h);
+      const e = t.get(y);
       return () => e.call(De.key);
     }
   }
@@ -1078,12 +1072,12 @@ n(Re.shortcuts, {
   displayName: "Keymap<orderedList>",
   group: "OrderedList"
 });
-const Pe = N("listItem");
+const Pe = I("listItem");
 n(Pe, {
   displayName: "Attr<listItem>",
   group: "ListItem"
 });
-const C = I("list_item", (t) => ({
+const M = C("list_item", (t) => ({
   group: "listItem",
   content: "paragraph block*",
   attrs: {
@@ -1103,7 +1097,7 @@ const C = I("list_item", (t) => ({
       tag: "li",
       getAttrs: (e) => {
         if (!(e instanceof HTMLElement))
-          throw S(e);
+          throw A(e);
         return {
           label: e.dataset.label,
           listType: e.dataset["list-type"],
@@ -1125,8 +1119,8 @@ const C = I("list_item", (t) => ({
   parseMarkdown: {
     match: ({ type: e }) => e === "listItem",
     runner: (e, r, a) => {
-      const o = r.label != null ? `${r.label}.` : "•", s = r.label != null ? "ordered" : "bullet", i = r.spread != null ? `${r.spread}` : "true";
-      e.openNode(a, { label: o, listType: s, spread: i }), e.next(r.children), e.closeNode();
+      const o = r.label != null ? `${r.label}.` : "•", s = r.label != null ? "ordered" : "bullet", l = r.spread != null ? `${r.spread}` : "true";
+      e.openNode(a, { label: o, listType: s, spread: l }), e.next(r.children), e.closeNode();
     }
   },
   toMarkdown: {
@@ -1136,69 +1130,69 @@ const C = I("list_item", (t) => ({
     }
   }
 }));
-n(C.node, {
+n(M.node, {
   displayName: "NodeSchema<listItem>",
   group: "ListItem"
 });
-n(C.ctx, {
+n(M.ctx, {
   displayName: "NodeSchemaCtx<listItem>",
   group: "ListItem"
 });
-const Ee = g("SinkListItem", () => () => Kt(C.type()));
+const Ee = h("SinkListItem", (t) => () => Kt(M.type(t)));
 n(Ee, {
   displayName: "Command<sinkListItemCommand>",
   group: "ListItem"
 });
-const _e = g("SplitListItem", () => () => et(C.type()));
+const _e = h("SplitListItem", (t) => () => et(M.type(t)));
 n(_e, {
   displayName: "Command<liftListItemCommand>",
   group: "ListItem"
 });
-const $e = g("SplitListItem", () => () => Dt(C.type()));
+const $e = h("SplitListItem", (t) => () => Dt(M.type(t)));
 n($e, {
   displayName: "Command<splitListItemCommand>",
   group: "ListItem"
 });
-const Ft = (t, e, r) => {
-  const { selection: a } = t;
-  if (!(a instanceof V))
+const Ft = (t) => (e, r, a) => {
+  const { selection: o } = e;
+  if (!(o instanceof G))
     return !1;
-  const { empty: o, $from: s } = a;
-  if (!o || s.parentOffset !== 0)
+  const { empty: s, $from: l } = o;
+  if (!s || l.parentOffset !== 0)
     return !1;
-  const i = s.node(-1);
-  return i.type !== C.type() || i.firstChild !== s.node() || s.node(-2).childCount > 1 ? !1 : et(C.type())(t, e, r);
-}, qe = g("LiftFirstListItem", () => () => Ft);
+  const i = l.node(-1);
+  return i.type !== M.type(t) || i.firstChild !== l.node() || l.node(-2).childCount > 1 ? !1 : et(M.type(t))(e, r, a);
+}, qe = h("LiftFirstListItem", (t) => () => Ft(t));
 n(qe, {
   displayName: "Command<liftFirstListItemCommand>",
   group: "ListItem"
 });
-const We = f("listItemKeymap", {
+const We = N("listItemKeymap", {
   NextListItem: {
     shortcuts: "Enter",
     command: (t) => {
-      const e = t.get(h);
+      const e = t.get(y);
       return () => e.call($e.key);
     }
   },
   SinkListItem: {
     shortcuts: ["Tab", "Mod-]"],
     command: (t) => {
-      const e = t.get(h);
+      const e = t.get(y);
       return () => e.call(Ee.key);
     }
   },
   LiftListItem: {
     shortcuts: ["Shift-Tab", "Mod-["],
     command: (t) => {
-      const e = t.get(h);
+      const e = t.get(y);
       return () => e.call(_e.key);
     }
   },
   LiftFirstListItem: {
     shortcuts: ["Backspace", "Delete"],
     command: (t) => {
-      const e = t.get(h);
+      const e = t.get(y);
       return () => e.call(qe.key);
     }
   }
@@ -1230,12 +1224,12 @@ n(gt, {
   displayName: "NodeSchema<text>",
   group: "Text"
 });
-const Fe = N("html");
+const Fe = I("html");
 n(Fe, {
   displayName: "Attr<html>",
   group: "Html"
 });
-const Ge = I("html", (t) => ({
+const Ge = C("html", (t) => ({
   atom: !0,
   group: "inline",
   inline: !0,
@@ -1282,12 +1276,12 @@ n(Ge.ctx, {
 const Gt = [
   nt,
   ge,
-  w,
-  Q,
+  v,
+  Y,
   ke,
-  A,
+  H,
   we,
-  x,
+  S,
   Ie,
   q,
   be,
@@ -1295,21 +1289,21 @@ const Gt = [
   He,
   F,
   Se,
-  O,
+  D,
   Be,
-  K,
+  R,
   Ke,
-  D,
+  P,
   Pe,
-  C,
+  M,
   ne,
-  Y,
+  z,
   le,
-  J,
+  U,
   de,
-  b,
+  x,
   pe,
-  v,
+  B,
   Fe,
   Ge,
   gt
@@ -1323,15 +1317,15 @@ const Gt = [
 ].flat(), jt = [
   he,
   Ce,
-  M,
+  b,
   fe,
-  xe,
+  Le,
   Ae,
   mt,
   it,
   ct,
   De,
-  Te,
+  Oe,
   Ee,
   $e,
   _e,
@@ -1343,21 +1337,21 @@ const Gt = [
   at
 ], zt = [
   Me,
-  Le,
+  xe,
   ve,
   Ne,
   We,
   Re,
-  Oe,
+  Te,
   ye,
   se,
   ue,
   ce
-].flat(), Ut = /\[([^\]]+)]\([^\s\]]+\)/, X = /\[(?<span>((www|https:\/\/|http:\/\/)[^\s\]]+))]\((?<url>[^\s\]]+)\)/, Yt = (t) => new RegExp(`\\\\(?=[^\\w\\s${t}\\\\]|_)`, "g"), Jt = (t) => {
-  let e = t, r = e.match(X);
+].flat(), Ut = /\[([^\]]+)]\([^\s\]]+\)/, Q = /\[(?<span>((www|https:\/\/|http:\/\/)[^\s\]]+))]\((?<url>[^\s\]]+)\)/, Yt = (t) => new RegExp(`\\\\(?=[^\\w\\s${t}\\\\]|_)`, "g"), Jt = (t) => {
+  let e = t, r = e.match(Q);
   for (; r && r.groups; ) {
     const { span: a } = r.groups;
-    e = e.replace(X, a), r = e.match(X);
+    e = e.replace(Q, a), r = e.match(Q);
   }
   return e;
 }, Qt = (t, e, r) => {
@@ -1369,15 +1363,15 @@ const Gt = [
 }, er = (t, e, r) => {
   let a = e, o = !1;
   return t.descendants((s) => {
-    var i;
+    var l;
     if (o)
       return !1;
     if (!s.textContent.includes(r))
       return a += s.nodeSize, !1;
     if (s.isText) {
-      const l = (i = s.text) == null ? void 0 : i.indexOf(r);
-      if (l != null && l >= 0)
-        return o = !0, a += l, !1;
+      const i = (l = s.text) == null ? void 0 : l.indexOf(r);
+      if (i != null && i >= 0)
+        return o = !0, a += i, !1;
     }
     return a += 1, !0;
   }), a;
@@ -1396,28 +1390,28 @@ const Gt = [
       e = Qt(e, a, a + 1), a = a + 1;
     return e;
   }
-}, R = ee(tr, "inlineSyncConfig");
-n(R, {
+}, E = Z(tr, "inlineSyncConfig");
+n(E, {
   displayName: "Ctx<inlineSyncConfig>",
   group: "Prose"
 });
 const rr = (t) => t.selection.$from.node(), ar = (t, e, r, a) => {
-  const o = t.get(At), s = e.schema.topNodeType.create(void 0, [r, ...a]);
+  const o = t.get(vt), s = e.schema.topNodeType.create(void 0, [r, ...a]);
   return o(s);
 }, nr = (t, e) => {
-  const r = t.get(R.key), a = r.placeholderConfig.hole, [o = "", ...s] = e.split(`
+  const r = t.get(E.key), a = r.placeholderConfig.hole, [o = "", ...s] = e.split(`
 
-`), i = (m) => r.movePlaceholder(a, m);
-  let c = wt(Xt(a), i, Jt)(o);
+`), l = (m) => r.movePlaceholder(a, m);
+  let c = At(Xt(a), l, Jt)(o);
   const d = Zt(r.placeholderConfig)(c);
   return c = c.replace(a, d), c = [c, ...s].join(`
 
 `), [c, d];
 }, or = (t, e) => {
-  const a = t.get(vt)(e);
+  const a = t.get(Ht)(e);
   return a ? a.firstChild : null;
 }, sr = (t, e) => {
-  const { globalNodes: r } = t.get(R.key), a = [];
+  const { globalNodes: r } = t.get(E.key), a = [];
   return e.doc.descendants((o) => {
     if (r.includes(o.type.name) || r.includes(o.type))
       return a.push(o), !1;
@@ -1426,52 +1420,52 @@ const rr = (t) => t.selection.$from.node(), ar = (t, e, r, a) => {
 
 `)[0] || "", ir = (t) => t.childCount === 1 && t.child(0).type.name === "html", ht = (t, e) => {
   try {
-    const r = sr(t, e), a = rr(e), o = ar(t, e, a, r), [s, i] = nr(t, o), l = or(t, s);
-    return !l || a.type !== l.type || ir(l) ? null : (l.attrs = { ...a.attrs }, l.descendants((c) => {
-      var u;
-      const m = c.marks.find((y) => y.type.name === "link");
-      m && ((u = c.text) != null && u.includes(i)) && m.attrs.href.includes(i) && (m.attrs.href = m.attrs.href.replace(i, ""));
+    const r = sr(t, e), a = rr(e), o = ar(t, e, a, r), [s, l] = nr(t, o), i = or(t, s);
+    return !i || a.type !== i.type || ir(i) ? null : (i.attrs = { ...a.attrs }, i.descendants((c) => {
+      var p;
+      const m = c.marks.find((u) => u.type.name === "link");
+      m && ((p = c.text) != null && p.includes(l)) && m.attrs.href.includes(l) && (m.attrs.href = m.attrs.href.replace(l, ""));
     }), {
       text: lr(s),
       prevNode: a,
-      nextNode: l,
-      placeholder: i
+      nextNode: i,
+      placeholder: l
     });
   } catch {
     return null;
   }
 }, cr = (t, e, r, a, o) => {
-  var E;
-  const { placeholderConfig: s } = t.get(R.key), i = s.hole;
-  let l = r.tr.setMeta(e, !0).insertText(i, r.selection.from);
-  const c = r.apply(l), d = ht(t, c);
+  var L;
+  const { placeholderConfig: s } = t.get(E.key), l = s.hole;
+  let i = r.tr.setMeta(e, !0).insertText(l, r.selection.from);
+  const c = r.apply(i), d = ht(t, c);
   if (!d)
     return;
-  const m = d.text.slice(0, d.text.indexOf(d.placeholder)), { $from: u } = c.selection, y = u.before(), p = u.after(), k = er(d.nextNode, y, d.placeholder);
-  l = l.replaceWith(y, p, d.nextNode).setNodeMarkup(y, void 0, o).delete(k + 1, k + 2), l = l.setSelection(V.near(l.doc.resolve(k + 1))), (Ut.test(m) || ["*", "_", "~"].includes(m.at(-1) || "")) && l.selection instanceof V && (((E = l.selection.$cursor) == null ? void 0 : E.marks()) ?? []).forEach((G) => {
-    l = l.removeStoredMark(G.type);
-  }), a(l);
-}, yt = H((t) => {
+  const m = d.text.slice(0, d.text.indexOf(d.placeholder)), { $from: p } = c.selection, u = p.before(), k = p.after(), g = er(d.nextNode, u, d.placeholder);
+  i = i.replaceWith(u, k, d.nextNode).setNodeMarkup(u, void 0, o).delete(g + 1, g + 2), i = i.setSelection(G.near(i.doc.resolve(g + 1))), (Ut.test(m) || ["*", "_", "~"].includes(m.at(-1) || "")) && i.selection instanceof G && (((L = i.selection.$cursor) == null ? void 0 : L.marks()) ?? []).forEach((J) => {
+    i = i.removeStoredMark(J.type);
+  }), a(i);
+}, yt = O((t) => {
   let e = null;
-  const r = new B("MILKDOWN_INLINE_SYNC");
-  return new T({
+  const r = new T("MILKDOWN_INLINE_SYNC");
+  return new K({
     key: r,
     state: {
       init: () => null,
-      apply: (a, o, s, i) => {
-        var k;
-        const l = t.get(Z);
-        if (!((k = l.hasFocus) != null && k.call(l)) || !l.editable || !a.docChanged || a.getMeta(r))
+      apply: (a, o, s, l) => {
+        var g;
+        const i = t.get(X);
+        if (!((g = i.hasFocus) != null && g.call(i)) || !i.editable || !a.docChanged || a.getMeta(r))
           return null;
-        const d = ht(t, i);
+        const d = ht(t, l);
         if (!d)
           return null;
         e && (cancelAnimationFrame(e), e = null);
-        const { prevNode: m, nextNode: u, text: y } = d, { shouldSyncNode: p } = t.get(R.key);
-        return p({ prevNode: m, nextNode: u, ctx: t, tr: a, text: y }) && (e = requestAnimationFrame(() => {
+        const { prevNode: m, nextNode: p, text: u } = d, { shouldSyncNode: k } = t.get(E.key);
+        return k({ prevNode: m, nextNode: p, ctx: t, tr: a, text: u }) && (e = requestAnimationFrame(() => {
           e = null;
-          const { dispatch: P, state: E } = t.get(Z);
-          cr(t, r, E, P, m.attrs);
+          const { dispatch: f, state: L } = t.get(X);
+          cr(t, r, L, f, m.attrs);
         })), null;
       }
     }
@@ -1501,15 +1495,15 @@ const ft = $(() => () => (t) => {
     if (!r.value || typeof r.value != "string")
       return;
     const s = [];
-    let i = 0;
+    let l = 0;
     e.lastIndex = 0;
-    let l = e.exec(r.value);
-    for (; l; ) {
-      const d = l.index;
-      i !== d && s.push({ type: "text", value: r.value.slice(i, d) }), s.push({ type: "break", data: { isInline: !0 } }), i = d + l[0].length, l = e.exec(r.value);
+    let i = e.exec(r.value);
+    for (; i; ) {
+      const d = i.index;
+      l !== d && s.push({ type: "text", value: r.value.slice(l, d) }), s.push({ type: "break", data: { isInline: !0 } }), l = d + i[0].length, i = e.exec(r.value);
     }
     if (s.length > 0 && o && typeof a == "number")
-      return i < r.value.length && s.push({ type: "text", value: r.value.slice(i) }), o.children.splice(a, 1, ...s), a + s.length;
+      return l < r.value.length && s.push({ type: "text", value: r.value.slice(l) }), o.children.splice(a, 1, ...s), a + s.length;
   });
 });
 n(ft, {
@@ -1526,19 +1520,19 @@ function ur(t, e) {
   return r(t, 0, null)[0];
   function r(a, o, s) {
     if (dr(a)) {
-      const i = [];
-      for (let l = 0, c = a.children.length; l < c; l++) {
-        const d = a.children[l];
+      const l = [];
+      for (let i = 0, c = a.children.length; i < c; i++) {
+        const d = a.children[i];
         if (d) {
-          const m = r(d, l, a);
+          const m = r(d, i, a);
           if (m)
-            for (let u = 0, y = m.length; u < y; u++) {
-              const p = m[u];
-              p && i.push(p);
+            for (let p = 0, u = m.length; p < u; p++) {
+              const k = m[p];
+              k && l.push(k);
             }
         }
       }
-      a.children = i;
+      a.children = l;
     }
     return e(a, o, s);
   }
@@ -1560,9 +1554,9 @@ n(Ct, {
   displayName: "Remark<remarkMarker>",
   group: "Remark"
 });
-const Mt = H(() => {
+const Mt = O(() => {
   let t = !1;
-  const e = new B("MILKDOWN_INLINE_NODES_CURSOR"), r = new T({
+  const e = new T("MILKDOWN_INLINE_NODES_CURSOR"), r = new K({
     key: e,
     state: {
       init() {
@@ -1571,34 +1565,34 @@ const Mt = H(() => {
       apply(a) {
         if (!a.selection.empty)
           return !1;
-        const o = a.selection.$from, s = o.nodeBefore, i = o.nodeAfter;
-        return !!(s && i && s.isInline && !s.isText && i.isInline && !i.isText);
+        const o = a.selection.$from, s = o.nodeBefore, l = o.nodeAfter;
+        return !!(s && l && s.isInline && !s.isText && l.isInline && !l.isText);
       }
     },
     props: {
       handleDOMEvents: {
         compositionend: (a, o) => t ? (t = !1, requestAnimationFrame(() => {
           if (r.getState(a.state)) {
-            const i = a.state.selection.from;
-            o.preventDefault(), a.dispatch(a.state.tr.insertText(o.data || "", i));
+            const l = a.state.selection.from;
+            o.preventDefault(), a.dispatch(a.state.tr.insertText(o.data || "", l));
           }
         }), !0) : !1,
         compositionstart: (a) => (r.getState(a.state) && (t = !0), !1),
         beforeinput: (a, o) => {
           if (r.getState(a.state) && o instanceof InputEvent && o.data && !t) {
-            const i = a.state.selection.from;
-            return o.preventDefault(), a.dispatch(a.state.tr.insertText(o.data || "", i)), !0;
+            const l = a.state.selection.from;
+            return o.preventDefault(), a.dispatch(a.state.tr.insertText(o.data || "", l)), !0;
           }
           return !1;
         }
       },
       decorations(a) {
         if (r.getState(a)) {
-          const i = a.selection.$from.pos, l = document.createElement("span"), c = ze.widget(i, l, {
+          const l = a.selection.$from.pos, i = document.createElement("span"), c = ze.widget(l, i, {
             side: -1
-          }), d = document.createElement("span"), m = ze.widget(i, d);
+          }), d = document.createElement("span"), m = ze.widget(l, d);
           return setTimeout(() => {
-            l.contentEditable = "true", d.contentEditable = "true";
+            i.contentEditable = "true", d.contentEditable = "true";
           }), Ue.create(a.doc, [c, m]);
         }
         return Ue.empty;
@@ -1611,27 +1605,27 @@ n(Mt, {
   displayName: "Prose<inlineNodesCursorPlugin>",
   group: "Prose"
 });
-const bt = H(() => new T({
-  key: new B("MILKDOWN_HARDBREAK_MARKS"),
-  appendTransaction: (t, e, r) => {
-    if (!t.length)
+const bt = O((t) => new K({
+  key: new T("MILKDOWN_HARDBREAK_MARKS"),
+  appendTransaction: (e, r, a) => {
+    if (!e.length)
       return;
-    const [a] = t;
-    if (!a)
+    const [o] = e;
+    if (!o)
       return;
-    const [o] = a.steps;
-    if (a.getMeta("hardbreak")) {
-      if (!(o instanceof Rt))
+    const [s] = o.steps;
+    if (o.getMeta("hardbreak")) {
+      if (!(s instanceof Rt))
         return;
-      const { from: l } = o;
-      return r.tr.setNodeMarkup(l, x.type(), void 0, []);
+      const { from: c } = s;
+      return a.tr.setNodeMarkup(c, S.type(t), void 0, []);
     }
-    if (o instanceof Pt) {
-      let l = r.tr;
-      const { from: c, to: d } = o;
-      return r.doc.nodesBetween(c, d, (m, u) => {
-        m.type === x.type() && (l = l.setNodeMarkup(u, x.type(), void 0, []));
-      }), l;
+    if (s instanceof Pt) {
+      let c = a.tr;
+      const { from: d, to: m } = s;
+      return a.doc.nodesBetween(d, m, (p, u) => {
+        p.type === S.type(t) && (c = c.setNodeMarkup(u, S.type(t), void 0, []));
+      }), c;
     }
   }
 }));
@@ -1639,51 +1633,51 @@ n(bt, {
   displayName: "Prose<hardbreakClearMarkPlugin>",
   group: "Prose"
 });
-const Ve = ee(["table", "code_block"], "hardbreakFilterNodes");
+const Ve = Z(["table", "code_block"], "hardbreakFilterNodes");
 n(Ve, {
   displayName: "Ctx<hardbreakFilterNodes>",
   group: "Prose"
 });
-const xt = H((t) => {
+const Lt = O((t) => {
   const e = t.get(Ve.key);
-  return new T({
-    key: new B("MILKDOWN_HARDBREAK_FILTER"),
+  return new K({
+    key: new T("MILKDOWN_HARDBREAK_FILTER"),
     filterTransaction: (r, a) => {
       const o = r.getMeta("hardbreak"), [s] = r.steps;
       if (o && s) {
-        const { from: i } = s, l = a.doc.resolve(i);
-        let c = l.depth, d = !0;
+        const { from: l } = s, i = a.doc.resolve(l);
+        let c = i.depth, d = !0;
         for (; c > 0; )
-          e.includes(l.node(c).type.name) && (d = !1), c--;
+          e.includes(i.node(c).type.name) && (d = !1), c--;
         return d;
       }
       return !0;
     }
   });
 });
-n(xt, {
+n(Lt, {
   displayName: "Prose<hardbreakFilterPlugin>",
   group: "Prose"
 });
-const Lt = H((t) => {
-  const e = new B("MILKDOWN_HEADING_ID"), r = (a) => {
+const xt = O((t) => {
+  const e = new T("MILKDOWN_HEADING_ID"), r = (a) => {
     if (a.composing || !a.editable)
       return;
-    const o = t.get(Q.key), s = a.state.tr.setMeta("addToHistory", !1);
-    let i = !1;
-    a.state.doc.descendants((l, c) => {
-      if (l.type === A.type()) {
-        if (l.textContent.trim().length === 0)
+    const o = t.get(Y.key), s = a.state.tr.setMeta("addToHistory", !1);
+    let l = !1;
+    a.state.doc.descendants((i, c) => {
+      if (i.type === H.type(t)) {
+        if (i.textContent.trim().length === 0)
           return;
-        const d = l.attrs, m = o(l);
-        d.id !== m && (i = !0, s.setMeta(e, !0).setNodeMarkup(c, void 0, {
+        const d = i.attrs, m = o(i);
+        d.id !== m && (l = !0, s.setMeta(e, !0).setNodeMarkup(c, void 0, {
           ...d,
           id: m
         }));
       }
-    }), i && a.dispatch(s);
+    }), l && a.dispatch(s);
   };
-  return new T({
+  return new K({
     key: e,
     view: (a) => (r(a), {
       update: (o) => {
@@ -1692,42 +1686,42 @@ const Lt = H((t) => {
     })
   });
 });
-n(Lt, {
+n(xt, {
   displayName: "Prose<syncHeadingIdPlugin>",
   group: "Prose"
 });
-const St = H(() => {
-  const t = (e) => {
-    if (e.composing || !e.editable)
+const St = O((t) => {
+  const e = (r) => {
+    if (r.composing || !r.editable)
       return;
-    const r = D.type(), a = K.type(), o = C.type(), s = e.state, i = (d, m) => {
+    const a = P.type(t), o = R.type(t), s = M.type(t), l = r.state, i = (m, p) => {
       let u = !1;
-      const y = `${m + 1}.`;
-      return d.label !== y && (d.label = y, u = !0), u;
+      const k = `${p + 1}.`;
+      return m.label !== k && (m.label = k, u = !0), u;
     };
-    let l = s.tr, c = !1;
-    s.doc.descendants((d, m, u, y) => {
-      if (d.type === a) {
-        const p = d.maybeChild(0);
-        (p == null ? void 0 : p.type) === o && p.attrs.listType === "ordered" && (c = !0, l.setNodeMarkup(m, r, { spread: "true" }), d.descendants((k, P, E, je) => {
-          if (k.type === o) {
-            const G = { ...k.attrs };
-            i(G, je) && (l = l.setNodeMarkup(P, void 0, G));
+    let c = l.tr, d = !1;
+    l.doc.descendants((m, p, u, k) => {
+      if (m.type === o) {
+        const g = m.maybeChild(0);
+        (g == null ? void 0 : g.type) === s && g.attrs.listType === "ordered" && (d = !0, c.setNodeMarkup(p, a, { spread: "true" }), m.descendants((f, L, wt, J) => {
+          if (f.type === s) {
+            const je = { ...f.attrs };
+            i(je, J) && (c = c.setNodeMarkup(L, void 0, je));
           }
           return !1;
         }));
-      } else if (d.type === o && (u == null ? void 0 : u.type) === r) {
-        const p = { ...d.attrs };
-        let k = !1;
-        p.listType !== "ordered" && (p.listType = "ordered", k = !0), (u == null ? void 0 : u.maybeChild(0)) && (k = i(p, y)), k && (l = l.setNodeMarkup(m, void 0, p), c = !0);
+      } else if (m.type === s && (u == null ? void 0 : u.type) === a) {
+        const g = { ...m.attrs };
+        let f = !1;
+        g.listType !== "ordered" && (g.listType = "ordered", f = !0), (u == null ? void 0 : u.maybeChild(0)) && (f = i(g, k)), f && (c = c.setNodeMarkup(p, void 0, g), d = !0);
       }
-    }), c && e.dispatch(l.setMeta("addToHistory", !1));
+    }), d && r.dispatch(c.setMeta("addToHistory", !1));
   };
-  return new T({
-    key: new B("MILKDOWN_KEEP_LIST_ORDER"),
-    view: (e) => (t(e), {
-      update: (r) => {
-        t(r);
+  return new K({
+    key: new T("MILKDOWN_KEEP_LIST_ORDER"),
+    view: (r) => (e(r), {
+      update: (a) => {
+        e(a);
       }
     })
   });
@@ -1737,18 +1731,18 @@ n(St, {
   group: "Prose"
 });
 const pr = [
-  R,
+  E,
   yt,
   bt,
   Ve,
-  xt,
+  Lt,
   Mt,
   kt,
   Nt,
   ft,
   It,
   Ct,
-  Lt,
+  xt,
   St
 ], vr = [Gt, Vt, jt, zt, pr].flat();
 export {
@@ -1756,42 +1750,42 @@ export {
   Me as blockquoteKeymap,
   q as blockquoteSchema,
   Be as bulletListAttr,
-  Oe as bulletListKeymap,
-  K as bulletListSchema,
+  Te as bulletListKeymap,
+  R as bulletListSchema,
   be as codeBlockAttr,
-  Le as codeBlockKeymap,
+  xe as codeBlockKeymap,
   W as codeBlockSchema,
   jt as commands,
   vr as commonmark,
-  xe as createCodeBlockCommand,
+  Le as createCodeBlockCommand,
   lt as createCodeBlockInputRule,
   tr as defaultConfig,
   nt as docSchema,
   fe as downgradeHeadingCommand,
   ne as emphasisAttr,
   se as emphasisKeymap,
-  Y as emphasisSchema,
+  z as emphasisSchema,
   we as hardbreakAttr,
   bt as hardbreakClearMarkPlugin,
   Ve as hardbreakFilterNodes,
-  xt as hardbreakFilterPlugin,
+  Lt as hardbreakFilterPlugin,
   ve as hardbreakKeymap,
-  x as hardbreakSchema,
+  S as hardbreakSchema,
   ke as headingAttr,
-  Q as headingIdGenerator,
+  Y as headingIdGenerator,
   Ne as headingKeymap,
-  A as headingSchema,
+  H as headingSchema,
   He as hrAttr,
   F as hrSchema,
   Fe as htmlAttr,
   Ge as htmlSchema,
   Se as imageAttr,
-  O as imageSchema,
+  D as imageSchema,
   de as inlineCodeAttr,
   ue as inlineCodeKeymap,
-  b as inlineCodeSchema,
+  x as inlineCodeSchema,
   Mt as inlineNodesCursorPlugin,
-  R as inlineSyncConfig,
+  E as inlineSyncConfig,
   yt as inlineSyncPlugin,
   Vt as inputrules,
   Ae as insertHardbreakCommand,
@@ -1803,16 +1797,16 @@ export {
   qe as liftFirstListItemCommand,
   _e as liftListItemCommand,
   pe as linkAttr,
-  v as linkSchema,
+  B as linkSchema,
   Pe as listItemAttr,
   We as listItemKeymap,
-  C as listItemSchema,
+  M as listItemSchema,
   Ke as orderedListAttr,
   Re as orderedListKeymap,
-  D as orderedListSchema,
+  P as orderedListSchema,
   ge as paragraphAttr,
   ye as paragraphKeymap,
-  w as paragraphSchema,
+  v as paragraphSchema,
   pr as plugins,
   kt as remarkAddOrderInListPlugin,
   It as remarkHtmlTransformer,
@@ -1824,8 +1818,8 @@ export {
   $e as splitListItemCommand,
   le as strongAttr,
   ce as strongKeymap,
-  J as strongSchema,
-  Lt as syncHeadingIdPlugin,
+  U as strongSchema,
+  xt as syncHeadingIdPlugin,
   St as syncListOrderPlugin,
   gt as textSchema,
   oe as toggleEmphasisCommand,
@@ -1838,9 +1832,9 @@ export {
   at as updateLinkCommand,
   Ce as wrapInBlockquoteCommand,
   st as wrapInBlockquoteInputRule,
-  Te as wrapInBulletListCommand,
+  Oe as wrapInBulletListCommand,
   ut as wrapInBulletListInputRule,
-  M as wrapInHeadingCommand,
+  b as wrapInHeadingCommand,
   ot as wrapInHeadingInputRule,
   De as wrapInOrderedListCommand,
   pt as wrapInOrderedListInputRule